﻿using Cheems.Interface.AI;
using Cheems.Interface.Configuration;
using Cheems.Interface.Models.AI;
using Cheems.Service.Models;
using MySqlX.XDevAPI;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace Cheems.Service.AI
{
    public class ChatService : IChat
    {
        private static readonly HttpClient client = new HttpClient();
        IConfig<ChatConfig> _chatConfig;

        public ChatService(IConfig<ChatConfig> chatConfig)
        {
            this._chatConfig = chatConfig;
        }

        AIRequestBody requestBody = new AIRequestBody();
        public async IAsyncEnumerable<string> GetChatGptResponse(string question)
        {
            // 更新请求体
            if (requestBody == null)
            {
                requestBody = new AIRequestBody();
            }
            requestBody.Messages.Add(
                new Message()
                {
                    Role = "user",
                    Content = question
                });

            // 将请求体序列化为 JSON 格式
            var content = new StringContent(JsonConvert.SerializeObject(requestBody), Encoding.UTF8, "application/json");

            // 创建 HTTP 请求消息
            var requestMessage = new HttpRequestMessage(HttpMethod.Post, this._chatConfig.GetConfig().BaseUrl)
            {
                Content = content
            };

            // 设置为流式请求
            requestMessage.Headers.Add("Accept", "application/json");

            // 使用 SendAsync 发送请求
            var response = await client.SendAsync(requestMessage, HttpCompletionOption.ResponseHeadersRead, CancellationToken.None);

            // 用于保存所有返回的结果
            var completeResponse = new StringBuilder();

            // 处理响应（流式输出）
            if (response.IsSuccessStatusCode)
            {
                // 获取响应流
                var stream = await response.Content.ReadAsStreamAsync();
                using (var reader = new StreamReader(stream))
                {
                    // 持续读取流中的数据，直到结束
                    while (!reader.EndOfStream)
                    {
                        var line = await reader.ReadLineAsync();
                        if (!string.IsNullOrWhiteSpace(line))
                        {
                            if (line.Contains("[DONE]"))
                            {
                                break;
                            }
                            // 确保只处理以 "data:" 开头的行
                            if (line.StartsWith("data:"))
                            {
                                // 去掉 'data:' 部分，提取 JSON 内容
                                string jsonContent = line.Substring(5).Trim();

                                // 防止空数据行（有些情况下可能返回空内容）
                                if (!string.IsNullOrWhiteSpace(jsonContent))
                                {
                                    // 解析每一行返回的 JSON 数据
                                    string assistantMessage = null;

                                    try
                                    {
                                        // 解析 JSON 数据
                                        var jsonResponse = JsonConvert.DeserializeObject<dynamic>(jsonContent);
                                        assistantMessage = jsonResponse?.choices[0]?.delta?.content;
                                    }
                                    catch (JsonReaderException ex)
                                    {
                                        // 捕获 JSON 解析错误，打印错误信息
                                        Console.WriteLine($"JSON 解析错误：{ex.Message}");
                                        Console.WriteLine($"错误行内容：{line}");
                                    }

                                    // 如果有有效内容，逐字返回并存储
                                    if (assistantMessage != null)
                                    {
                                        yield return assistantMessage; // 实时返回每个字的输出
                                        completeResponse.Append(assistantMessage); // 拼接完整响应
                                    }
                                }
                            }
                        }
                    }
                }

                // 完成流式请求后，可以根据需要保存或处理 completeResponse
                string finalResponse = CleanText(completeResponse.ToString());
                requestBody.Messages.Add(
                new Message()
                {
                    Role = "assistant",
                    Content = finalResponse
                });
            }
            else
            {
                // 请求失败，输出错误信息
                string errorContent = await response.Content.ReadAsStringAsync();
                Console.WriteLine($"请求失败：{response.StatusCode}");
                Console.WriteLine("错误详情：" + errorContent); // 打印详细的错误信息
                yield break; // 结束流式返回
            }
        }

        public string CleanText(string input)
        {
            // 移除 <think></think> 标签及其中的内容
            string noThinkContent = Regex.Replace(input, "<think>.*?</think>", string.Empty, RegexOptions.Singleline);

            // 移除换行符
            string cleanedText = Regex.Replace(noThinkContent, @"\r\n|\n|\r", string.Empty);

            return cleanedText;
        }


    }
}
